Ext.namespace('Rumore.form');

Rumore.form.noRumoreForm1 = function(config){

	var _this = this

	// ########## TAB 0 ##########
 
	var idautorizza = {xtype:'hidden', name:'idautorizza'}
	var idprocedimento = {xtype:'hidden', name:'idprocedimento', value: appContext.currentIdProcedimento}
	
// 	var richiedente = {xtype:'textfield', name:'richiedente', fieldLabel:'Richiedente',}
	var richQualif = {xtype:'textfield',name:'qualita', fieldLabel:'Qualifica richiedente'}
//	var ditta	= {xtype:'textfield', name:'ditta', fieldLabel:'Attività - denominazione ',}

	//var professione	= {xtype:'textfield', name:'professione', fieldLabel:'Professione', readOnly:true}
	var id_ente = {xtype:'hidden', name:'id_ente', value: appContext.currentEnte}

	var fiscale	= {xtype:'textfield', name:'fiscale', fieldLabel:'Codice Fiscale - Partita IVA', readOnly:true}
	var domfiscale	= {xtype:'textfield', name:'domfiscale', fieldLabel:'Indirizzo', readOnly:true}

	var indirUnitLoc = {xtype:'textfield', name:'indirunitloc', fieldLabel:'Unità locale - indirizzo', readOnly: true}
//	var ulsel	= {xtype:'button',}
// 	var unitalocale = {xtype:'textfield', name:'unita', fieldLabel:'ragione sociale',}
	var impiantooggetto	= {xtype:'textfield', name:'impiantooggetto', fieldLabel:'Impianto/Attività',}

	// ---------

	var storeCiclo = new Ext.data.SimpleStore({
		fields: ['cicloattivita'],
		data: [['ciclo continuo'],['diurno'],['serale'],['notturno']]
	});

	var storeClassi = new Ext.data.SimpleStore({
		fields:['classi'],
		data:[['classe I'],['classe II'],['classe III'],['classe IV'],['classe V'],['classe VI']]
	});
	
	var storeFreq = new Ext.data.SimpleStore({
		fields: ['freqattivita'],
		data: [['continuo'],['discontinuo'],['saltuario']]
	});

	//-----

	// ######### TAB 1 ###########

	var longdescimp	= {xtype:'htmleditor', height:100, width:400, enableFont: false, enableLinks: false, enableSourceEdit: false, name:'descrizioneimpianto', fieldLabel:'Descrizione impianto/attività'}

	var impiantiFreq = {xtype:'combo', store: storeFreq, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, 		displayField: 'freqattivita', hiddenName:'frequenza', fieldLabel: 'Frequenza attività'}

	var impiantiCiclo = {xtype:'combo', store: storeCiclo, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, 		displayField: 'cicloattivita', hiddenName:'ciclo', fieldLabel: 'Ciclo attività'}

	var classeImpianti = {xtype:'combo', store: storeClassi, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, displayField: 'classi', hiddenName:'classeacusticaimp', fieldLabel: 'Classe zona rumore' }


	var emissioneImpianto = {xtype:'textfield', name:'livellosorg', fieldLabel:'Livello emissione - dB'}

	var climaSonoro = {xtype:'textfield', name:'climasonoro', fieldLabel:'Clima sonoro preesistente'}

	var contribSonoro = {xtype:'textfield', name:'contributo', fieldLabel:'Contributo rumore'}


	// ######### TAB 2 ###########


//	var classUnita = {xtype:'combo', store: storeClassi, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, 		displayField: 'classi', hiddenName:'classeAcusticaImp', fieldLabel: 'Classificazione acustica area impianto'}
// 	var classRicettori = {xtype:'combo', store: storeClassi, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, 		displayField: 'classi', hiddenName:'classeAcusticaRec', fieldLabel: 'Classificazione acustica area recettori'}
	
	var dsSorgentiGrid = new Ext.data.JsonStore({
		url:'',
		fields:['descrsorg','dbemissione']

	})
	var cmSorg = new Ext.grid.ColumnModel([
		{ header:'sorgente', dataIndex:'descrsorg', width:350, editor: new Ext.form.TextField({ allowBlank:false})},
		{ header:'dB emissione', dataIndex:'dbemissione', width:120, editor: new Ext.form.TextField({ allowBlank:false, maxLength:20})}


	]);
	var insertSorg = Ext.data.Record.create([
		{name:'descrsorg', type:'string'},
		{name:'dbemissione', type:'string'}
	])
	var gridSorgente = new Ext.grid.EditorGridPanel({
		cm: cmSorg,
		ds: dsSorgentiGrid,		
		width:600,
		height:200,
		title:'Sorgenti rumore',
		frame:true,
		sm: new Ext.grid.RowSelectionModel({singleSelect: true}),
		tbar:[{
			text:'inserisci',
			handler: function(){
				var nuovo = new insertSorg({
					descrsorg: '',
					dbemissione:''

				});
				gridSorgente.stopEditing();
				dsSorgentiGrid.insert(0,nuovo);
				gridSorgente.startEditing(0,0);
			}
		},{
			text:'elimina',
			handler: function(){

				var selModel = gridSorgente.getSelectionModel();
				var selection = selModel.getSelected();
	
				deletedSorgTmp.push(selection.data);
				dsSorgentiGrid.remove(selection);
			
			}
		}]

	})


	// ########### TAB 3 ############

	// griglia  distanze da ricettori rumore
	var dsRicettoriGrid = new Ext.data.JsonStore({
		//autoLoad: true,
		url:'',
		fields:['idricettore','descrizione','distanza', 'classe']
	})	

	var storeRicettori = new Ext.data.SimpleStore({fields:['rifdist'], data:[['abitazione singola'], ['gruppo abitazioni'], ['condominio/i'], ['scuola'], ['ospedale'], ['casa riposo'], ['edifici/spazi collettivi']] })
	var cm = new Ext.grid.ColumnModel([
		{ header:'ricettore', dataIndex:'descrizione',  width:200, editor:new Ext.form.ComboBox({ store: storeRicettori, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, displayField: 'rifdist', hiddenName:'descrizione' }) 
		},
		{ header:'distanza (metri)', dataIndex:'distanza', width:120, hiddenName:'distanza', editor: new Ext.form.TextField({ allowBlank:false, maskRe:/[0-9]/, maxLength:20})},
		{ header:'classe', dataIndex:'classe',  width:150, editor:new Ext.form.ComboBox({ store: storeClassi, emptyText:'Seleziona ...',  mode:'local', typeAhead: true, triggerAction: 'all', selectOnFocus:true, displayField: 'classi', hiddenName:'classe' })}

	]);
	var insert = Ext.data.Record.create([
		{name:'descrizione', type:'string'},
		{name:'distanza', type:'string'},
		{name:'classe', type:'string'}
	])

	var gridRicettori = new Ext.grid.EditorGridPanel({
		cm: cm,
		ds: dsRicettoriGrid,		
		width:600,
		height:200,
		title:'Ricettori',
		frame:true,
		sm: new Ext.grid.RowSelectionModel({singleSelect: true}),
		tbar:[{
			text:'inserisci',
			handler: function(){
				var nuovo = new insert({
					descrizione: '',
					distanza:'',
					classe:''
				});
				gridRicettori.stopEditing();
				dsRicettoriGrid.insert(0,nuovo);
				gridRicettori.startEditing(0,0);
			}
		},{
			text:'elimina',
			handler: function(){

				var selModelRicettori = gridRicettori.getSelectionModel();
				var selRicettori = selModelRicettori.getSelected();
	
				deletedRicettTmp.push(selRicettori.data);
				dsRicettoriGrid.remove(selRicettori);
			
			}
		}]

	})


	// ########### TAB 4 ############


	var abbattimento = {xtype:'htmleditor', height:120, width:400, enableFont: false, enableLinks: false, enableSourceEdit: false, name:'mitigaesist', fieldLabel:'Mitigazioni esistenti'}
	
	var mitiga = {xtype:'htmleditor', height:120, width:400, enableFont: false, enableLinks: false, enableSourceEdit: false, name:'mitigaprev', fieldLabel:'Mitigazioni previste'}

	// ########### TAB 5 ############
	
	var dataNo = {xtype:'datefield', name:'protocollodata', fieldLabel:'Data Nulla Osta', format:'d.m.Y'}
	var protNo = {xtype:'numberfield', name:'protocollonum', fieldLabel:'Protocollo Nulla Osta'}

	var limiteEmissDiurno = {xtype:'textfield', name:'limiteemissionediurno', fieldLabel:'Limite emissione diurno - dB'}
	var limiteEmissNotte = {xtype:'textfield', name:'limiteemissionenotturno', fieldLabel:'Limite emissione notturno - dB'}
	var limiteImmissDiurno = {xtype:'textfield', name:'limiteimmissionediurno', fieldLabel:'Limite immissione diurno - dB'}
	var limiteImmissNotte = {xtype:'textfield', name:'limiteimmissionenotturno', fieldLabel:'Limite immissione notturno - dB'}
	
	var limiteDiffDiurno = {xtype:'textfield', name:'limitedifferenzialediurno', fieldLabel:'Limite differenziale diurno - dB'} 
	var limiteDiffNotturno = {xtype:'textfield', name:'limitedifferenzialenotturno', fieldLabel:'Limite differenziale notturno - dB'}


	var formDefaults = { border: false, style:'padding:10px', labelWidth: 250}
	var itemDefaults = { anchor:'99%'}

	var richSel	= {xtype:'trigger', 
				onTriggerClick : function(){
					var main = new Anagrafica.app.Main({
						onCaricaSelezione: function(record){
							var richiedente = {
								data:{
									richiedente:record.data.ragsoc,
									//fiscale:record.data.codfisc
								}
							}							
							_this.getForm().loadRecord(richiedente);
						}
					});
				}, 
				readOnly : true,
				fieldLabel:'Richiedente' ,
				fit:true,
				triggerClass : 'x-trigger-search x-form-clear-trigger' ,
				itemCls  : 'x-trigger-comp-element' ,
				name:'richiedente',
				id:'trigger-richiedente' ,
				allowBlank:false

        }
	
	var idAnagProfessionista = {xtype:'hidden', name:'professionista', id:'idprofessionista'};

	
	Ext.app.SearchField = Ext.extend(
			
		Ext.form.TwinTriggerField, {
		
	    initComponent : function(){
	     
			Ext.app.SearchField.superclass.initComponent.call(this);
			this.on('specialkey', function(f, e){
	            if(e.getKey() == e.ENTER){
	                this.onTrigger2Click();
	            }
	        }, this);
	    },

	    validationEvent:false,
	    validateOnBlur:false,
	    trigger1Class:'x-form-search-trigger',
	    trigger2Class:'x-form-clear-trigger',
	    hideTrigger1:false,
	    hideTrigger2:false,
	    onTrigger1Click : function(record){
	    	var main = new AnagProcedure.app.Main({
				//url : '/commongest/CommonServlet/anagrafica/anagraficaProfessioniSel',
	    		url:'/commongest/CommonServlet/anagrafica/anagraficaProcedureSel',
				title:'Elenco Professionisti',
				disableBtnNuovaIscrizione:true,
				baseParams:{},
				onCaricaSelezione: function(record){
					
					var professionista = {
						data:{
							nomeprofessionista:record.data.ragsoc,
							professionista:record.data.idAdresse
							//fiscale:record.data.codfisc
						}
					}							
					_this.getForm().loadRecord(professionista);
					
					var cmbProfessioni = _this.getForm().findField('professione');
					cmbProfessioni.setValue("");
					cmbProfessioni.store.baseParams={idAdresse:record.data.idAdresse};
					cmbProfessioni.store.reload({
						callback:function(){
							cmbProfessioni.setValue(
								cmbProfessioni.store.getAt(0).data.idAnagProf
								
							); 
						}
					});
				}
			});
			
	    },

	    onTrigger2Click : function(){
	    	
	       	this.setRawValue('');
	    	Ext.getCmp('autRumoreForm-professione').clearValue();
	    	Ext.getCmp('idprofessionista').setRawValue('');

	    }
	});
	
	
	var profSel= new Ext.app.SearchField({
			
			readOnly : true,
			fieldLabel:'professionista.' ,
			fit:true,
			name:'nomeprofessionista',
			id:'trigger-professionista' ,
			allowBlank:true


	})
	

	var professione = new Ext.form.ComboBox({
		id:'autRumoreForm-professione',
		hiddenName:'professione', 
		fieldLabel:'Professione',
		displayField:'titolo',
		valueField:'idAnagProf',
		store:new Ext.data.JsonStore({ 
			baseParams:{idAdresse:-1},
			url:'/commongest/CommonServlet/professioni/list',
			fields:['idAnagProf',
				'idAdresse',
				'numOrdine',
				'titolo']
		}),
		typeAhead: true,
		forceSelection: true,
		triggerAction: 'all',
		selectOnFocus:true,
		readOnly : true,
		allowBlank:true
	});


	var idAttivita = {xtype:'hidden', name:'idattivita'}
	

	

	var dittaSel = {xtype:'trigger', 
				onTriggerClick : function(){
					//alert('hai cliccato sulla ditta')
					var ditta = new AttivitaProc.app.Main({
						disableBtnNuovaAttivita:true,
						onCaricaSelezione: function(record){
						
							var attivita = {
								data:{
									idattivita:record.data.idattivita,
									ditta:record.data.anagrafica.ragsoc,
									fiscale:record.data.anagrafica.codfisc,
									domfiscale:record.data.cap+" "+record.data.citta+" - "+record.data.via+', '+record.data.nciv	
								}
							}							
							_this.getForm().loadRecord(attivita);
							
							var cmbAttivitaLocale = _this.getForm().findField('idattivitalocale');
							cmbAttivitaLocale.setValue("");
							cmbAttivitaLocale.store.baseParams={attivitalocale:record.data.idattivita, id_ente:appContext.currentEnte};
							cmbAttivitaLocale.store.reload({
								callback:function(){
								cmbAttivitaLocale.setValue(
										cmbAttivitaLocale.store.getAt(0).data.idattivita
									);
								var fieldAttLocIndir = _this.getForm().findField('indirunitloc');
								fieldAttLocIndir.setValue(cmbAttivitaLocale.store.getAt(0).data.cap+" "+cmbAttivitaLocale.store.getAt(0).data.citta+" - "+cmbAttivitaLocale.store.getAt(0).data.via+", "+cmbAttivitaLocale.store.getAt(0).data.nciv);

								}
							});
						//console.dir(record)
							}
					});


				}, 
			readOnly : true,
			fieldLabel:'Attività - denominazione' ,
			fit:true,
			triggerClass : 'x-trigger-search' ,
			name:'ditta',
			id:'trigger-ditta' ,
			allowBlank:false
	}

//	var unitLocSel	= {xtype:'trigger', 
//				onTriggerClick : function(){
//				//apertura window
//				}, 
//			readOnly : true,
//			fieldLabel:'Unità locale' ,
//			fit:true,
//			triggerClass : 'x-trigger-search' ,
//			name:'unitalocale',
//			id:'trigger-unitalocale' ,
//			allowBlank:false
//        }
	
	var unitaLocCmb = new Ext.form.ComboBox({
		id:'autRumoreForm-unitaLoc',
		hiddenName:'idattivitalocale', 
		fieldLabel:'Unità Locale',
		displayField:'ragsociale',
		valueField:'idattivita',
		store:new Ext.data.JsonStore({ 
			baseParams:{attivitalocale:-1},
			url:'/commongest/CommonServlet/anagditte/attivitaSel',
			fields:['idattivita',
			        'idattivitalocale',
			        'ragsociale',
			        'via',
			        'cap',
			        'citta',
			        'nciv'
			]
		}),
		listeners:{
			select: function(combo, record, index){
         		
        		var txtUnitaLocIndir = _this.getForm().findField('indirunitloc');
        		txtUnitaLocIndir.setValue(record.data.cap+" "+record.data.citta+" - "+record.data.via+", "+record.data.nciv)
        		
        		
    		}
		},
		typeAhead: true,
		forceSelection: true,
		triggerAction: 'all',
		readOnly: true,
		selectOnFocus:true 
	});	
	
	

	var datigenerali = {
		labelWidth:170,
		title:'Dati generali',
		items:[idautorizza, idprocedimento, id_ente, idAttivita, idAnagProfessionista, dittaSel, fiscale, domfiscale, unitaLocCmb, indirUnitLoc, impiantooggetto, profSel, professione],
		defaults:{anchor:'98%'}
	}

	var impianti = {
		labelWidth:170,
		title:'Attività/Impianti',
		items:[longdescimp,  impiantiCiclo, impiantiFreq, classeImpianti, emissioneImpianto, climaSonoro, contribSonoro],
		defaults:{anchor:'98%'}

	}


	var sorgenti = {
	
		title:'Sorgenti',
		items:[gridSorgente],
		defaults:{anchor:'98%'}

	}

	var ricettori = {
		title:'Ricettori',
		items:[gridRicettori],
		defaults:{anchor:'98%'}

	}

	var mitigazioni = {
		labelWidth:120,
		title:'Mitigazioni',
		items:[abbattimento, mitiga],
		defaults:{anchor:'98%'}

	}

	var nullaosta = {
		labelWidth:200,
		title:'Nulla Osta',
		items:[dataNo, protNo, limiteEmissDiurno, limiteEmissNotte, limiteImmissDiurno, limiteImmissNotte, limiteDiffDiurno, limiteDiffNotturno],
		defaults:{anchor:'98%'}

	}



	var tabpanel = new Ext.TabPanel({
		deferredRender:false,
		autoHeight:true,
		items: [datigenerali, impianti, sorgenti, ricettori, mitigazioni, nullaosta],
		activeTab: 0,
		defaults:{layout: 'form', frame: true, autoHeight:true}
	})



	
	var deletedSorgTmp = [];
	
	this.clearSorgTmp = function(){
		deletedSorgTmp = [];
	
	}
	
	var deletedRicettTmp = [];
	
	this.clearRicettTmp = function(){
		
		deletedRicettTmp = [];
		
	}
	
	
	this.saveFormData = function(){

		if(!_this.getForm().isValid()){ 
			Ext.MessageBox.alert('Inserire i dati mancanti!');
			return;
		}	
		
		
			var recordSaving = _this.getForm().getValues();
	
			var aSorgentiRecords = [];
		
			Ext.each(dsSorgentiGrid.getModifiedRecords(), function(record){aSorgentiRecords.push(record.data)}); //carica l'array 'arecords'
		
			var aRicettoriRecords = [];
			
			Ext.each(dsRicettoriGrid.getModifiedRecords(), function(record){aRicettoriRecords.push(record.data)})
			
		
		recordSaving.sorgenti = aSorgentiRecords;
		recordSaving.sorgentieliminate = deletedSorgTmp;
		
		recordSaving.ricettori = aRicettoriRecords;
		recordSaving.ricettorieliminati = deletedRicettTmp;
		
			var dataparams = Ext.util.JSON.encode(recordSaving)

 //		console.log("parametri:  --- "+dataparams)

		
		
		Ext.Ajax.request({
			url:'/commongest/CommonServlet/anagditte/salvaAutRumore',
			method:'POST',
			params:{json:dataparams},
			
			success: function(resp,opt){
				var respObj = Ext.decode(resp.responseText)
				if(respObj.success){
				 	updatedata = true;
//				 	dsIstatSecond.commitChanges();
				 	Ext.MessageBox.alert('Salvataggio avvenuto');
				} else Ext.MessageBox.alert('dati non salvati!');
			},
			failure: function(resp, opt){
				Ext.MessageBox.alert('dati non salvati!');
			}

		});	
  		
  			_this.clearSorgTmp();
  			_this.clearRicettTmp();

	}

	
	var defaults = {
			id:'autRumoreForm',
			items:[tabpanel],
			frame:true,
			monitorResize:true,
			defaults: formDefaults,
			setRecord: function(record){
				
				//console.dir(_this.getForm())
		
				var dsProfessioni = Ext.getCmp('autRumoreForm-professione').store;
				dsProfessioni.loadData([{idAnagProf:record.data.professione, titolo:record.data.professioneDescr}]);
				
				var dsUnitaLocale = Ext.getCmp('autRumoreForm-unitaLoc').store;
				dsUnitaLocale.loadData([{idattivita:record.data.idattivitalocale, ragsociale:record.data.unitLocDescr}]);
				
				//devo caricare su un array tutti gli elementi della sottostruttura ricettori del json
				var ricettori=[];
				for(i=0;i<record.data.ricettori.length;i++)
					ricettori.push({idricettore:record.data.ricettori[i].idricettore, descrizione:record.data.ricettori[i].descrizione, distanza:record.data.ricettori[i].distanza, classe:record.data.ricettori[i].classe})
			    dsRicettoriGrid.loadData(ricettori);	        

				var sorgentiNamed = [];
				for(key in record.data.sorgenti ){
					sorgentiNamed.push( {descrsorg:key,dbemissione:record.data.sorgenti[key]} );
				}
				dsSorgentiGrid.loadData(sorgentiNamed)
				
				_this.getForm().loadRecord(record) //espongo la funzione nativa per caricare il form con il record	
			}
	}
	

	Rumore.form.noRumoreForm1.superclass.constructor.call(this, Ext.apply({},  config , defaults))
 

}


Ext.extend(Rumore.form.noRumoreForm1, Ext.form.FormPanel);

//registro l'oggetto EditForm
Ext.reg('norumoreformedit_a', Rumore.form.noRumoreForm1)
